const dataKit = require("./dataKit")
const dateKit = require("./dateKit")

/**
 * 注意：使用await的方法必须加上async，不然会报错！！
 */
module.exports = {

  /**
   * 增加或减少抽奖次数
   * @param {*} content 
   * @param {*} count 
   */
  async addGameTime(context, option) {

    const { cloud, openId } = context;

    // 获取当前时间
    let curr = await dateKit.getCurrentDateTime();

    // 乐观锁
    const result = await cloud.db.collection('c_user').find(
      {
        open_id: openId
      },
      {
        limit: 1,
      }
    );

    // return result[0].version;

    // 高并发情况下程序可能会绕过调用addGameTime之前的抽奖次数检测，为安全起见需要在此处再做一次抽奖次数判空


    console.log('获取到的用户信息为：'.result)

    if (result == null || result == undefined) {
      console.log('增加游戏机会接口报错，用户信息错误')
      return { code: -1, msg: '用户信息错误' }
    }


    // 如果option为-1，则执行减1操作
    if (option) {
      //获取并保存version版本号，作为乐观锁的判断标致 
      let versionStatus = result[0].version
      // 以用户的乐观锁（version版本号和openid）为依据修改用户抽奖次数
      const addOk = await dataKit.update(context, 'c_user',
        {
          open_id: openId,
          version: versionStatus
        },
        {
          version: versionStatus + 1,
          lottery_number: result[0].lottery_number + 1,
          update_time: curr
        }
      )
      // return addOk;
      // 数据回传
      if (addOk == 0 || addOk == null || addOk == '') return { code: -1, msg: '抽奖次数添加失败！', data: '并发错误111111' + addOk }
      return { code: 1, msg: '抽奖次数添加成功', data: addOk }

    } else {
      if (result[0].lottery_number == 0) return { code: -1, msg: '并发错误！抽奖次数已经为0' }
      //获取并保存version版本号，作为乐观锁的判断标致 
      let versionStatus = result[0].version
      // 以用户的乐观锁（version版本号和openid）为依据修改用户抽奖次数
      const cutOk = await dataKit.update(context, 'c_user',
        {
          open_id: openId,
          version: versionStatus
        },
        {
          version: versionStatus + 1,
          lottery_number: result[0].lottery_number - 1,
          update_time: curr
        }
      )
      // 数据回传
      if (cutOk != 1) return { code: -1, msg: '抽奖次数减少失败！', data: '并发错误1112222222' + cutOk }
      return { code: 1, msg: '抽奖次数减少成功', data: cutOk }
    }
  },





  /**
 * 减少库存
 * @param {*} content 
 * @param {*} count 
 */
  async reduceStock(context, giftIndex, gift_id) {
    // 乐观锁
    var giftResultInfo = await dataKit.findOne(context, 'gift',
      {
        gift_index: giftIndex
      }
    )
    console.log('获取到的用户信息为：'.giftResultInfo)

    if (giftResultInfo == null || giftResultInfo == undefined) {
      console.log('增加游戏机会接口报错，用户信息错误')
      return { code: -1, msg: '用户信息错误' }
    }

    // 判断是否库存为0后程序还继续往下走
    if (giftResultInfo.gift_num == 0) return { code: -1, msg: '并发错误！奖品库存已经为0' }

    //获取并保存version版本号，作为乐观锁的判断标致 
    let versionStatus = giftResultInfo.version
    // 以用户的乐观锁（version版本号和openid）为依据修改用户抽奖次数
    let updateOk = await dataKit.update(context, 'gift',
      {
        _id: gift_id,
        version: versionStatus,
        gift_index: giftIndex
      },
      {
        version: versionStatus + 1,
        gift_num: giftResultInfo.gift_num - 1
      }
    )
    // 数据回传
    if (updateOk.length == 0) return { code: -1, msg: '减库存失败！', data: '并发错误' + updateOk }

    return { code: 1, msg: '减库存成功！' }
  },



  /**
   * 
   * 抽奖日志记录
   * @param {} context 
   * @param {*} openId 
   */
  async drawLog(context, giftInfo) {
    const current = await dateKit.getCurrentDateTime();
    const { openId } = context;
    const option = {
      gift_index: giftInfo.gift_index,
      open_id: openId,
      gift_id: giftInfo.gift_id,
      gift_name: giftInfo.gift_name,
      gift_url: giftInfo.gift_url,
      gift_image: giftInfo.gift_image,
      draw_state: 0,
      create_time: current,
    }
    // const result = await cloud.db.collection('data_buried_point').insertOne(option)
    const result = await dataKit.insertOne(context, 'draw_log', option)
    if (!result) return { code: -1, msg: option.gift_name + '埋点记录失败！' }
    return { code: 1, msg: option.gift_name + '埋点记录添加成功！' }
  },

  /**
   * 查询该用户是否中过某种奖品
   * @param {*} context 
   * @param {*} openId 
   */
  async checkDraw(context, gift_index) {
    // if(gift_index == 7) return false;
    const { openId } = context;
    let result = false;
    const findResult = dataKit.findOne(context, 'draw_log',
      {
        open_id: openId,
        gift_index: gift_index
      });

    if (findResult != null || findResult.length > 0) result = findResult;

    return result;

  },





  /**
   * table task_log
   * 一个用户只能完成一次关注任务(已完成)
   */
  async follow(context) {
    const { NickName } = context.data;
    const { openId } = context;
    //  const  {NickName} = context.data;

    // const openId = 'AAFO8CdUANgGe-d5nzQZbBoY';
    // const NickName = 'tb045044225';
    const currTime = await dateKit.getCurrentDateTime();

    // 查询用户是否完成关注任务
    var result = await dataKit.findOne(context, 'task_log',
      {
        type: 'FOLLOW',
        open_id: openId
      }
    )

    if (result) {
      return { code: 0, msg: '该用户已经关注过了' }
    }

    // 执行添加游戏次数操作
    let addOk = await this.addGameTime(context, true);

    if (!addOk) return { code: -1, msg: '游戏次数增加失败！' };

    //  添加用户关注店铺日志
    let insertOk = await dataKit.insertOne(context, 'task_log',
      {
        name: '关注',
        open_id: openId,
        nick_name: NickName,
        type: 'FOLLOW',
        create_time: currTime,
      }
    )

    if (!insertOk) return { code: -1, msg: '关注失败，数据库操作失败！' }
    return { code: 1, msg: '关注成功' }
  },


  /**
   * table task_log
   * 用户本人入会(已完成)
   */
  async member(context) {
    const { openId } = context;
    const { NickName } = context.data;

    // const openId = 'AAFO8CdUANgGe-d5nzQZbBoY';
    // const NickName = 'tb045044225';
    const currTime = await dateKit.getCurrentDateTime();

    // 查询用户是否完成关注任务
    var result = await dataKit.findOne(context, 'task_log',
      {
        type: 'MEMBER',
        open_id: openId
      }
    )

    if (result) {
      return { code: 0, msg: '该用户已经入过会了！' }
    }

    // 执行添加游戏次数操作
    let addOk = await this.addGameTime(context, true);

    if (!addOk) return { code: -1, msg: '游戏次数增加失败！' };

    //  添加用户关注店铺日志
    let insertOk = await dataKit.insertOne(context, 'task_log',
      {
        name: '入会',
        open_id: openId,
        nick_name: NickName,
        type: 'MEMBER',
        create_time: currTime,
      }
    )

    if (!insertOk) return { code: -1, msg: '入会失败，数据库操作失败！' }
    return { code: 1, msg: '入会成功' }
  },




  /**
   * 
   * @param {任务名称} taskName 
   * @param {任务开始时间} task_start 
   * @param {任务结束时间} task_end 
   */
  async judgeState(taskName, task_start, task_end) {
    const nowTime = await dateKit.getCurrentDateTime();
    const compare1 = await dateKit.compare(task_start, nowTime)  //1表示未开始
    // const compare2 = await dateKit.compare(nowTime, task_end)  // 1:表示可以补签
     const isNow = nowTime.split(" ")[0] === task_start.split(" ")[0];

    if(compare1 == 1){
      return {code:-1,msg:"活动未开始",taskName: taskName,taskTime:task_start}
    }else{
      if(isNow){
        return {code:0,msg:"活动可以正常完成",taskName: taskName,taskTime:task_start}
      }else{
        return {code:1,msg:'活动可以补签',taskName: taskName,taskTime:task_start}
      }
    }

    // console.log(nowTime)
    // console.log(task_start)
    // 表示活动已经开始
   
 
    // if (isNow){
    //   return { code: 0, msg: '活动可以正常完成', taskName: taskName }
    // } else{
      // if(compare1 == -1){
      //   if(compare2 == 1){
      //     return {code: -1, msg: '活动可以补签', taskName: taskName }
      //   }else {
      //      return {code: -1, msg: '活动可以补签', taskName: taskName }
      //   }
      //   // return {code: -1, msg: '活动已经开始', taskName: taskName }
      // } else {
      //   return  {code: -1, msg: '活动未开始', taskName: taskName }
      // }
      // return {compare1: compare1 == 1, compare2: compare2 == 1}
      // return compare1 == 1 ? { code: -1, msg: '活动未开始', taskName: taskName } : { code: -1, msg: '活动未开始', taskName: taskName }
      // return compare2 == 1 ? { code: -1, msg: '活动未开始', taskName: taskName } : { code: -1, msg: '活动未开始', taskName: taskName }
    // if (compare2 == 1) return { code: 1, msg: '活动可以补签', taskName: taskName }
    // }
  },



  /**
   * 因某种情况引导抽奖人未中奖且自动扣除游戏次数
   */
  async deduction(context) {
    const { openId } = context;
    // 减去抽奖次数
    return this.addGameTime(context, openId, '-1')
  },




  // 判断收藏是否需要为该用户添加抽奖次数
  async addCollectGoods(context) {
    const { openId } = context;
    const goods = await dataKit.find(context, 'task_log',
      {
        open_id: openId,
        type: 'COLLECTGOODS'
      }
    )
    let goods1 = await goods.filter((item) => {
      return item.goodsId == '639741596007';

    });
    let goods2 = await goods.filter((item) => {
      return item.goodsId == '4552289532259';
    });
    if ((goods.length >= 5) && goods1 && goods2) {
      await this.addGameTime(context, true)
      return { code: 2, msg: '任务点已完成' }
    } else {
      return { code: 3 }
    }
  },



  // 判断加购是否需要为该用户添加抽奖次数
  async addAddShopCar(context) {
    const { openId } = context;
    const goods = await dataKit.find(context, 'task_log',
      {
        open_id: openId,
        type: 'ADDSHOPCAR'
      }
    )
      let goods1 = await goods.filter((item) => {
      return item.goodsId == '639741596007';

    });
    let goods2 = await goods.filter((item) => {
      return item.goodsId == '4552289532259';
    });
    if (goods.length >= 5 && goods1 && goods2) {
      await this.addGameTime(context, true)
      return { code: 2, msg: '任务点已完成' }
    } else {
      return { code: 3 }
    }
  }
}









